home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / Origami / Sources / src / origami / signals.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  9.3 KB  |  468 lines
  1. /*{{{}}}*/
  2. /*{{{  #includes*/
  3. #ifdef CONFIG_H
  4. #   include "config.h"
  5. #endif
  6.  
  7. #include <sys/types.h>
  8. #include <errno.h>
  9. #include <limits.h>
  10. #include <signal.h>
  11. #include <unistd.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include <time.h>
  16.  
  17. #define SIGNALS_C
  18. #define I_BUFFLOOP_C
  19. #define I_DISPLAY_C
  20. #define I_FOLDFILING_C
  21. #define I_FOLDING_C
  22. #define I_GETMSG_C
  23. #define I_GETTK_C
  24. #define I_INIT_C
  25. #define I_KEYBOARD_C
  26. #define I_LOOP_C
  27. #define I_MAIN_C
  28. #define I_MESSAGES_C
  29. #define I_PROMPT_C
  30. #define I_SCREEN_C
  31. #define I_VIRTUAL_C
  32.  
  33. #include "exit.h"
  34. #include "origami.h"
  35. #include "lib/ori_add_lib.h"
  36. /*}}}  */
  37.  
  38. /*{{{  variables*/
  39. #ifdef USE_SCRBUFF
  40.    public boolean redraw_on_sig=True;
  41. #endif
  42. public boolean do_dump=False;
  43. /*}}}  */
  44.  
  45. /*{{{  append_sig_token*/
  46. private void append_sig_token(TOKEN t)
  47. {
  48.   if (redraw_on_sig)
  49.      interrupt_restore=True;
  50.   if (t && sig_count<HISTORY_SIZE)
  51.    { sig_macro[sig_count++]=t;
  52.      sig_macro[sig_count]=M_END_MACRO;
  53.      ocl_msg("append signal token %d",t);
  54.    }
  55. }
  56. /*}}}  */
  57. /*{{{  append_sig_macro*/
  58. #define append_sig_macro(x) append_sig_token((x)+O_EXE_MACRO)
  59. /*}}}  */
  60.  
  61. /*{{{  check/set_time_events*/
  62. /*{{{  variables*/
  63. struct tp
  64.  { boolean running;
  65.    time_t point;
  66.  } clock_event={ False,0 },
  67.    alarm_event={ False,0 };
  68. /*}}}  */
  69. private int upd_time(time_t*);
  70. private void got_alarm(void);
  71.  
  72. /*{{{  check_time_event*/
  73. public void check_time_event(void)
  74. {
  75.   if (clock_event.running || alarm_event.running)
  76.    /*{{{  get time and check events*/
  77.    { time_t t;
  78.  
  79.      time(&t);
  80.      if (clock_event.running && t>=clock_event.point)
  81.       /*{{{  update*/
  82.         clock_event.point=t+upd_time(&t);
  83.       /*}}}  */
  84.      if (alarm_event.running && t>=alarm_event.point)
  85.       /*{{{  handle the alarm*/
  86.       { alarm_event.running=False;
  87.         got_alarm();
  88.       }
  89.       /*}}}  */
  90.    }
  91.    /*}}}  */
  92. }
  93. /*}}}  */
  94. /*{{{  set_alarm_event*/
  95. private void set_alarm_event(int delay)
  96. {
  97.   if (delay)
  98.    /*{{{  get current time and set timer*/
  99.    { time_t t;
  100.  
  101.      time(&t);
  102.      alarm_event.running=True;
  103.      alarm_event.point=t+delay;
  104.    }
  105.    /*}}}  */
  106.   else
  107.      alarm_event.running=False;
  108. }
  109. /*}}}  */
  110. /*}}}  */
  111. /*{{{  time-timer*/
  112. public char time_str[]="\0(hh:mm)";
  113. private boolean timing=False;
  114.  
  115. /*{{{  upd_time*/
  116. private int upd_time(time_t *t)
  117. { struct tm *tdat;
  118.  
  119.   if (timing && (tdat=localtime(t)))
  120.    /*{{{  decode time*/
  121.    { int x;
  122.  
  123.      time_str[0]=' ';
  124.      x=tdat->tm_hour;
  125.      time_str[2]=hex_digits[x/10];
  126.      time_str[3]=hex_digits[x%10];
  127.      x=tdat->tm_min;
  128.      time_str[5]=hex_digits[x/10];
  129.      time_str[6]=hex_digits[x%10];
  130.      title_op(CHGTITLE);
  131.      return(60-tdat->tm_sec);
  132.    }
  133.    /*}}}  */
  134.   else
  135.    /*{{{  empty string*/
  136.    { time_str[0]='\0';
  137.      return(0);
  138.    }
  139.    /*}}}  */
  140. }
  141. /*}}}  */
  142. /*{{{  switch_time*/
  143. public int switch_time(boolean on)
  144. {
  145.   boolean old;
  146.  
  147.   /*{{{  maybe change status line*/
  148.   if (timing!=on)
  149.      title_op(CHGTITLE);
  150.   /*}}}  */
  151.   old=timing;
  152.   /*{{{  set time string to correct value*/
  153.   if ((timing=on))
  154.    { clock_event.running=True;
  155.      clock_event.point=0;
  156.      check_time_event();
  157.    }
  158.   else
  159.      time_str[0]='\0';
  160.   /*}}}  */
  161.  
  162.   return(old?1:0);
  163. }
  164. /*}}}  */
  165. /*}}}  */
  166. /*{{{  autosave-timer*/
  167. private boolean alarm_running=False;
  168. public int alarm_time = -1;
  169.  
  170. /*{{{  got_alarm*/
  171. private void got_alarm(void)
  172. {
  173.   if (auto_save && alarm_running)
  174.      append_sig_token(O_AUTO_SAVE);
  175.   ocl_msg("got alarm",0);
  176. }
  177. /*}}}  */
  178. /*{{{  set_alarm*/
  179. public void set_alarm(int delay,boolean secs)
  180. {
  181.   alarm_running=True;
  182.   if (delay!=0)
  183.    { alarm_time=delay;
  184.      if (!secs)
  185.       /*{{{  use minutes, check standard intervall*/
  186.       { alarm_time*=60;
  187.         if (alarm_time<MIN_ALARMTIME*60 || alarm_time>MAX_ALARMTIME*60)
  188.          /*{{{  complain and set to default*/
  189.          { message
  190.             ( get_msg
  191.                ( MSG_ARG_FORMAT,
  192.                  "["STR_F_ALARM"]",
  193.                  MIN_ALARMTIME,
  194.                  MAX_ALARMTIME
  195.                )
  196.             );
  197.            alarm_time=NORM_ALARMTIME*60;
  198.          }
  199.          /*}}}  */
  200.       }
  201.       /*}}}  */
  202.    }
  203.   set_alarm_event(alarm_time);
  204. }
  205. /*}}}  */
  206. /*{{{  reset_alarm*/
  207. public void reset_alarm(void)
  208. {
  209.   set_alarm_event(0);
  210. }
  211. /*}}}  */
  212. /*}}}  */
  213.  
  214. /*{{{  job control*/
  215. #ifdef _POSIX_JOB_CONTROL
  216. private void bktoshell(void);
  217. private void rtfrmshell(void);
  218.  
  219. /*{{{  bktoshell           stop origami*/
  220. private void bktoshell(void)
  221. { pid_t pid;
  222.  
  223.   signal(SIGTSTP,SIG_IGN);
  224.   signal(SIGSTOP,SIG_DFL);
  225.   msg_message(M_SUSPEND);
  226.   reset_keyboard();
  227.   reset_terminal();
  228.   pid = getpid();
  229.   kill(pid,SIGSTOP);
  230. }
  231. /*}}}  */
  232. /*{{{  rtfrmshell          wake origami up*/
  233. private void rtfrmshell()
  234. {
  235.   signal(SIGTSTP,SIG_IGN);
  236.   signal(SIGCONT,(void(*)())rtfrmshell);
  237.   signal(SIGSTOP,(void(*)())bktoshell);
  238.   init_terminal();
  239.   init_keyboard();
  240.   B_invalid();
  241.   auto_flush();
  242.   ori_assert(bd.scr.cur_shift_w<=LINELEN,"shift-check");
  243.   title_op(PRTTITLE);
  244. }
  245. /*}}}  */
  246. #endif
  247. /*{{{  suspend             suspend Origami and wait to wake up*/
  248. public void suspend(void)
  249. {
  250. # ifdef _POSIX_JOB_CONTROL
  251.      if (!no_suspend)
  252.         bktoshell();
  253.      else
  254. # endif
  255.         msg_message(M_NO_JOB);
  256. }
  257. /*}}}  */
  258. /*}}}  */
  259.  
  260. /*{{{  exit_origami*/
  261. public void exit_origami(RETURNS c, unsigned char const *string)
  262. { static int exiting=0;
  263.  
  264.   rcclose();
  265.   /*{{{  maybe dumb files*/
  266. #  ifdef NOMEMDUMP
  267.     paket_free(mem_dump_malloc);
  268. #  endif
  269.   if (    !exiting++
  270.        && (    c==r_sig
  271.             || c==r_ocl_err
  272.             || c==r_eof
  273. #           ifdef NOMEMDUMP
  274.             || c==r_mem_full
  275. #           endif
  276.           )
  277.   ) mail_and_dump(c);
  278.   /*}}}  */
  279.   /*{{{  end_data_handle*/
  280. #  ifdef VIRTUAL
  281.      if (end_data_handle())
  282.       { oputc('\n');
  283.         oputs(get_msg(F_VM_FAIL,"access",strerror(errno)));
  284.         c=r_vir_err;
  285.       }
  286. #  endif
  287. #  ifdef AUTOSAVE_FILE
  288.      if (autosave_done) unlink(AUTOSAVE_FILE);
  289. #  endif
  290.   /*}}}  */
  291.   if (string)
  292.    { eputc('\n');
  293.      eputs((unsigned char*)string);
  294.    }
  295.   close(msg_file);
  296.   reset_terminal();
  297.   reset_keyboard();
  298. # ifdef WINDOW_TITLE_CHANGE
  299.      chg_w_title(w_title);
  300. # endif
  301.   end_debug();
  302.   exit(c);
  303. }
  304. /*}}}  */
  305.  
  306. /*{{{  warn_cpu*/
  307. #ifdef SIGXCPU
  308. private void warn_cpu(void)
  309. {
  310.   bell_audible();
  311.   bell_visible();
  312.   warn_message((unsigned char*)" Did you know you had a CPU-quota? - Now you do :-) ");
  313. }
  314. #endif
  315. /*}}}  */
  316. /*{{{  got_sterm*/
  317. private void got_sterm(void)
  318. {
  319.   ocl_msg("got sterm",0);
  320.   exit_origami(r_sig,(unsigned char*)"terminated");
  321. }
  322. /*}}}  */
  323. /*{{{  got_scrash*/
  324. private void got_scrash(void)
  325. {
  326.   boolean crashed=False;
  327.  
  328.   ocl_msg("got scrash",0);
  329.   if (!crashed)
  330.    { crashed=True;
  331.      exit_origami(r_sig,(unsigned char*)"crashed");
  332.    }
  333.   exit(r_sig);
  334. }
  335. /*}}}  */
  336.  
  337. /*{{{  got_squit*/
  338. private void got_squit(void)
  339. {
  340.   ocl_msg("got squit",0);
  341.   if (!squit_macro)
  342.      got_sterm();
  343.   append_sig_macro(squit_macro);
  344.   signal(SIGQUIT,(void(*)())got_squit);
  345. }
  346. /*}}}  */
  347. /*{{{  got_susr1*/
  348. #ifdef SIGUSR1
  349. private void got_susr1(void)
  350. {
  351.   ocl_msg("got susr1",0);
  352.   append_sig_macro(susr1_macro);
  353.   signal(SIGUSR1,(void(*)())got_susr1);
  354. }
  355. #endif
  356. /*}}}  */
  357. /*{{{  got_susr2*/
  358. #ifdef SIGUSR2
  359. private void got_susr2(void)
  360. {
  361.   ocl_msg("got susr2",0);
  362.   append_sig_macro(susr2_macro);
  363.   signal(SIGUSR2,(void(*)())got_susr2);
  364. }
  365. #endif
  366. /*}}}  */
  367. /*{{{  got_winchg*/
  368. #ifdef SIGWINCH
  369. private void got_winchg()
  370. {
  371.   ocl_msg("got swinchg",0);
  372.   append_sig_token(O_REFRESH);
  373.   win_changed=True;
  374.   signal(SIGWINCH,(void(*)())got_winchg);
  375. }
  376. #endif
  377. /*}}}  */
  378.  
  379. /*{{{  init_signals()*/
  380. public void init_signals(void)
  381. {
  382.   if (!do_dump)
  383.    /*{{{  signals, which call got_scrash=got_sterm or exit*/
  384.    {
  385. #     ifdef SIGPWR
  386.         signal(SIGPWR,(void(*)())got_scrash);
  387. #     endif
  388. #     ifdef SIGILL
  389.         signal(SIGILL,(void(*)())got_scrash);
  390. #     endif
  391. #     ifdef SIGSYS
  392.         signal(SIGSYS,(void(*)())got_scrash);
  393. #     endif
  394. #     ifdef SIGBUS
  395.         signal(SIGBUS,(void(*)())got_scrash);
  396. #     endif
  397. #     ifdef SIGSEGV
  398.         signal(SIGSEGV,(void(*)())got_scrash);
  399. #     endif
  400.    }
  401.    /*}}}  */
  402.   /*{{{  SIGTERM       got_sterm=dump*/
  403. #  ifdef SIGTERM
  404.      signal(SIGTERM,(void(*)())got_sterm);
  405. #  endif
  406.   /*}}}  */
  407.   /*{{{  SIGHUP        got_sterm=dump*/
  408. #  ifdef SIGHUP
  409.      if (signal(SIGHUP,(void(*)())got_sterm)==SIG_IGN)
  410.          signal(SIGHUP,SIG_IGN);
  411. #  endif
  412.   /*}}}  */
  413.   /*{{{  SIGQUIT       got_squit=got_sterm or ocl-macro*/
  414. #  ifdef SIGQUIT
  415.      signal(SIGQUIT,(void(*)())got_squit);
  416. #  endif
  417.   /*}}}  */
  418.   /*{{{  SIGUSR1       got_susr1=macro or nothing*/
  419. #  ifdef SIGUSR1
  420.      signal(SIGUSR1,(void(*)())got_susr1);
  421. #  endif
  422.   /*}}}  */
  423.   /*{{{  SIGUSR2       got_susr2=macro or nothing*/
  424. #  ifdef SIGUSR2
  425.      signal(SIGUSR2,(void(*)())got_susr2);
  426. #  endif
  427.   /*}}}  */
  428.   /*{{{  SIGALRM       ignore*/
  429. #  ifdef SIGALRM
  430.      signal(SIGALRM,SIG_IGN);
  431. #  endif
  432.   /*}}}  */
  433.   /*{{{  SIGPIPE       ignore*/
  434. #  ifdef SIGPIPE
  435.      signal(SIGPIPE,SIG_IGN);
  436. #  endif
  437.   /*}}}  */
  438.   /*{{{  SIGXCPU       warn_cpu*/
  439. #  ifdef SIGXCPU
  440.      signal(SIGXCPU,(void(*)())warn_cpu);
  441. #  endif
  442.   /*}}}  */
  443.   /*{{{  SIGXFSZ       ignore*/
  444. #  ifdef SIGXFSZ
  445.      signal(SIGXFSZ,SIG_IGN);
  446. #  endif
  447.   /*}}}  */
  448.   /*{{{  SIGWINCH      got_winchg=refresh*/
  449. #  ifdef SIGWINCH
  450.      signal(SIGWINCH,(void(*)())got_winchg);
  451. #  endif
  452.   /*}}}  */
  453.   /*{{{  SIGTSTP       ignore*/
  454. #  ifdef SIGTSTP
  455.      signal(SIGTSTP,SIG_IGN);
  456. #  endif
  457.   /*}}}  */
  458.   /*{{{  _POSIX_JOB_CONTROL*/
  459. #  ifdef _POSIX_JOB_CONTROL
  460.      signal(SIGCONT,(void(*)())rtfrmshell);
  461.      signal(SIGSTOP,(void(*)())bktoshell);
  462.      signal(SIGTSTP,SIG_IGN);
  463. #  endif
  464.   /*}}}  */
  465.   disable_abort();
  466. }
  467. /*}}}  */
  468.